home *** CD-ROM | disk | FTP | other *** search
/ Express Pd: GALORE / Express Pd Galore - The Amiga PD & Shareware CD (1994)(Express Pd)[!][Amiga-CD32-CDTV].iso / productivity / term / termdebug.c < prev    next >
C/C++ Source or Header  |  1993-07-16  |  6KB  |  338 lines
  1. /*
  2. **    termDebug.h
  3. **
  4. **    Support routines for memory allocation debugging
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel & MXM
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* The original system routines. */
  13.  
  14. APTR OldAllocVec(LONG,ULONG);
  15. VOID OldFreeVec(APTR);
  16.  
  17. #pragma libcall SysBase OldAllocVec 2AC 1002
  18. #pragma libcall SysBase OldFreeVec 2B2 901
  19.  
  20. APTR OldAllocMem(LONG,ULONG);
  21. VOID OldFreeMem(APTR,LONG);
  22.  
  23. #pragma libcall SysBase OldAllocMem C6 1002
  24. #pragma libcall SysBase OldFreeMem D2 0902
  25.  
  26.     /* A custom node type. */
  27.  
  28. struct SomeNode
  29. {
  30.     struct MinNode    MinNode;    /* Exec link. */
  31.  
  32.     APTR        Data;        /* Actual data instance. */
  33.     LONG        Size;        /* Actual data size. */
  34.     ULONG        Attributes;    /* Allocation attributes. */
  35.     UBYTE        Name[32];    /* The name of the task to make the call. */
  36.  
  37.     UBYTE        File[80];    /* The file the call came from. */
  38.     LONG        Line;        /* The file line the call came from. */
  39. };
  40.  
  41.     /* Local data. */
  42.  
  43. STATIC struct MinList        *SomeList;
  44. STATIC struct SignalSemaphore    *SomeSemaphore;
  45.  
  46. #ifdef DEBUG_COVER
  47.  
  48. extern long __far _CoverStart;
  49. extern long __far _CoverLength;
  50.  
  51. VOID
  52. CoverInit()
  53. {
  54.     STATIC BYTE CoverInfoRead = FALSE;
  55.  
  56.     if(!CoverInfoRead)
  57.     {
  58.         BPTR FileHandle;
  59.  
  60.         if(FileHandle = Open("cover.dat",MODE_OLDFILE))
  61.         {
  62.             UBYTE Tag[4];
  63.  
  64.             if(Read(FileHandle,Tag,4) == 4)
  65.             {
  66.                 if(!memcmp(Tag,"COV",4))
  67.                 {
  68.                     LONG Length;
  69.  
  70.                     if(Read(FileHandle,&Length,sizeof(LONG)) == sizeof(LONG))
  71.                     {
  72.                         if(Length == (LONG)&_CoverLength)
  73.                             Read(FileHandle,&_CoverStart,Length);
  74.                     }
  75.                 }
  76.             }
  77.  
  78.             Close(FileHandle);
  79.         }
  80.  
  81.         CoverInfoRead = TRUE;
  82.     }
  83. }
  84.  
  85. VOID
  86. CoverExit()
  87. {
  88.     BPTR FileHandle;
  89.  
  90.     if(FileHandle = Open("cover.dat",MODE_NEWFILE))
  91.     {
  92.         BYTE Success    = FALSE;
  93.         LONG Length    = (LONG)&_CoverLength;
  94.  
  95.         if(Write(FileHandle,"COV",4) == 4)
  96.         {
  97.             if(Write(FileHandle,&Length,sizeof(LONG)) == sizeof(LONG))
  98.             {
  99.                 if(Write(FileHandle,&_CoverStart,Length) == Length)
  100.                     Success = TRUE;
  101.             }
  102.         }
  103.  
  104.         Close(FileHandle);
  105.  
  106.         if(Success)
  107.             SetProtection("cover.dat",FIBF_EXECUTE);
  108.         else
  109.             DeleteFile("cover.dat");
  110.     }
  111. }
  112.  
  113. #endif    /* DEBUG_COVER */
  114.  
  115.     /* DebugExit(VOID):
  116.      *
  117.      *    Unlink the debugging support code.
  118.      */
  119.  
  120. VOID
  121. DebugExit(VOID)
  122. {
  123.     if(SomeList)
  124.     {
  125.         struct SomeNode *Node,*Next;
  126.  
  127.         ObtainSemaphore(SomeSemaphore);
  128.  
  129.         Node = (struct SomeNode *)SomeList -> mlh_Head;
  130.  
  131.         if(Node -> MinNode . mln_Succ)
  132.         {
  133.             kprintf("Adress     Size       Attributes Allocated by\n---------- ---------- ---------- --------------------------------\n");
  134.  
  135.             while(Next = (struct SomeNode *)Node -> MinNode . mln_Succ)
  136.             {
  137.                 kprintf("0x%08lx %10ld 0x%08lx »%s«\n",Node -> Data,Node -> Size,Node -> Attributes,Node -> Name);
  138.     
  139.                 if(Node -> File[0])
  140.                     kprintf(": File »%s», Line %ld\n",Node -> File,Node -> Line);
  141.  
  142.                 Remove((struct Node *)Node);
  143.  
  144.                 OldFreeMem(Node,Node -> Size + sizeof(struct SomeNode));
  145.  
  146.                 Node = Next;
  147.             }
  148.         }
  149.         else
  150.             kprintf("*** No remaining memory blocks\n");
  151.  
  152.         ReleaseSemaphore(SomeSemaphore);
  153.  
  154.         OldFreeVec(SomeList);
  155.  
  156.         SomeList = NULL;
  157.  
  158.         OldFreeVec(SomeSemaphore);
  159.  
  160.         SomeSemaphore = NULL;
  161.     }
  162. }
  163.  
  164.     /* DebugInit(VOID):
  165.      *
  166.      *    Initialize the debugging support code.
  167.      */
  168.  
  169. VOID
  170. DebugInit(VOID)
  171. {
  172.     if(SomeList = (struct MinList *)OldAllocVec(sizeof(struct MinList),MEMF_ANY | MEMF_PUBLIC))
  173.     {
  174.         NewList((struct List *)SomeList);
  175.  
  176.         if(SomeSemaphore = (struct SignalSemaphore *)OldAllocVec(sizeof(struct SignalSemaphore),MEMF_ANY | MEMF_PUBLIC))
  177.         {
  178.             InitSemaphore(SomeSemaphore);
  179.  
  180.             return;
  181.         }
  182.  
  183.         OldFreeVec(SomeList);
  184.  
  185.         SomeList = NULL;
  186.     }
  187. }
  188.  
  189.     /* New custom memory allocation routines. */
  190.  
  191. VOID __regargs
  192. FreeVecNew(APTR Data)
  193. {
  194.     if(SomeList)
  195.     {
  196.         struct SomeNode *Node,*Next;
  197.  
  198.         ObtainSemaphore(SomeSemaphore);
  199.  
  200.         Node = (struct SomeNode *)SomeList -> mlh_Head;
  201.  
  202.         while(Next = (struct SomeNode *)Node -> MinNode . mln_Succ)
  203.         {
  204.             if(Node -> Data == Data)
  205.             {
  206.                 Remove((struct Node *)Node);
  207.  
  208.                 OldFreeMem(Node,Node -> Size + sizeof(struct SomeNode));
  209.  
  210.                 break;
  211.             }
  212.             else
  213.                 Node = Next;
  214.         }
  215.  
  216.         ReleaseSemaphore(SomeSemaphore);
  217.     }
  218.     else
  219.         OldFreeVec(Data);
  220. }
  221.  
  222. APTR __regargs
  223. AllocVecNew(LONG Size,ULONG Attributes,LONG Line,STRPTR File)
  224. {
  225.     if(SomeList)
  226.     {
  227.         struct SomeNode *Node;
  228.  
  229.         if(Node = (struct SomeNode *)OldAllocMem(sizeof(struct SomeNode) + Size,Attributes))
  230.         {
  231.             Node -> Data        = (APTR)(Node + 1);
  232.             Node -> Size        = Size;
  233.             Node -> Attributes    = Attributes;
  234.  
  235.             if(SysBase -> ThisTask -> tc_Node . ln_Name)
  236.             {
  237.                 memcpy(Node -> Name,SysBase -> ThisTask -> tc_Node . ln_Name,32);
  238.  
  239.                 Node -> Name[31] = 0;
  240.             }
  241.             else
  242.                 strcpy(Node -> Name,"*** Namenlos ***");
  243.  
  244.             memcpy(Node -> File,File,80);
  245.  
  246.             Node -> File[79] = 0;
  247.  
  248.             Node -> Line = Line;
  249.  
  250.             ObtainSemaphore(SomeSemaphore);
  251.  
  252.             AddHead((struct List *)SomeList,(struct Node *)Node);
  253.  
  254.             ReleaseSemaphore(SomeSemaphore);
  255.  
  256.             return(Node -> Data);
  257.         }
  258.         else
  259.             return(NULL);
  260.     }
  261.     else
  262.         return(OldAllocVec(Size,Attributes));
  263. }
  264.  
  265. VOID __regargs
  266. FreeMemNew(APTR Data,LONG Size)
  267. {
  268.     if(SomeList)
  269.     {
  270.         struct SomeNode *Node,*Next;
  271.  
  272.         ObtainSemaphore(SomeSemaphore);
  273.  
  274.         Node = (struct SomeNode *)SomeList -> mlh_Head;
  275.  
  276.         while(Next = (struct SomeNode *)Node -> MinNode . mln_Succ)
  277.         {
  278.             if(Node -> Data == Data)
  279.             {
  280.                 Remove((struct Node *)Node);
  281.  
  282.                 OldFreeMem(Node,Node -> Size + sizeof(struct SomeNode));
  283.  
  284.                 break;
  285.             }
  286.             else
  287.                 Node = Next;
  288.         }
  289.  
  290.         ReleaseSemaphore(SomeSemaphore);
  291.     }
  292.     else
  293.         OldFreeMem(Data,Size);
  294. }
  295.  
  296. APTR __regargs
  297. AllocMemNew(LONG Size,ULONG Attributes,LONG Line,STRPTR File)
  298. {
  299.     if(SomeList)
  300.     {
  301.         struct SomeNode *Node;
  302.  
  303.         if(Node = (struct SomeNode *)OldAllocMem(sizeof(struct SomeNode) + Size,Attributes))
  304.         {
  305.             Node -> Data        = (APTR)(Node + 1);
  306.             Node -> Size        = Size;
  307.             Node -> Attributes    = Attributes;
  308.  
  309.             if(SysBase -> ThisTask -> tc_Node . ln_Name)
  310.             {
  311.                 memcpy(Node -> Name,SysBase -> ThisTask -> tc_Node . ln_Name,32);
  312.  
  313.                 Node -> Name[31] = 0;
  314.             }
  315.             else
  316.                 strcpy(Node -> Name,"*** Namenlos ***");
  317.  
  318.             memcpy(Node -> File,File,80);
  319.  
  320.             Node -> File[79] = 0;
  321.  
  322.             Node -> Line = Line;
  323.  
  324.             ObtainSemaphore(SomeSemaphore);
  325.  
  326.             AddHead((struct List *)SomeList,(struct Node *)Node);
  327.  
  328.             ReleaseSemaphore(SomeSemaphore);
  329.  
  330.             return(Node -> Data);
  331.         }
  332.         else
  333.             return(NULL);
  334.     }
  335.     else
  336.         return(OldAllocMem(Size,Attributes));
  337. }
  338.